package com.mdxx.xczd.utils;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.provider.Settings;
import android.telephony.PhoneStateListener;
import android.telephony.SignalStrength;
import android.telephony.TelephonyManager;
import android.telephony.cdma.CdmaCellLocation;
import android.telephony.gsm.GsmCellLocation;
import android.util.Log;

import com.mdxx.xczd.app.App;
import com.orhanobut.logger.Logger;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.text.DecimalFormat;

public class NetworkUtil {  
	private final static int NET_UNKNOWN = 0x06;
	private final static int WIFI = 0x05;
	private final static int NET_4G = 0x04;
	private final static int NET_3G = 0x03;
	private final static int NET_2G = 0x02;	
	private final static int NET_NONE = 0x00;
	public static boolean isWifiAvailable() {  
		ConnectivityManager connectivityManager = (ConnectivityManager) App
				.getAppContext().getSystemService(Context.CONNECTIVITY_SERVICE);  
		NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();  
		return (networkInfo != null && networkInfo.isConnected() && networkInfo  
				.getType() == ConnectivityManager.TYPE_WIFI);  
	}  

	/** 
	 * 获取MAC地址 
	 *  
	 * @param context 
	 * @return 
	 */  
	public static String getMacAddress(Context context) {  
		if (context == null) {  
			return "";  
		}  

		String localMac = null;  
		if (isWifiAvailable()) {  
			localMac = getWifiMacAddress(context);  
		}  

		if (localMac != null && localMac.length() > 0) {  
			localMac = localMac.replace(":", "-").toLowerCase();  
			return localMac;  
		}  

		localMac = getMacFromCallCmd();  
		if (localMac != null) {  
			localMac = localMac.replace(":", "-").toLowerCase();  
		}  

		return localMac;  
	}  

	private static String getWifiMacAddress(Context context) {  
		String localMac = null;  
		try {  
			WifiManager wifi = (WifiManager) context  
					.getSystemService(Context.WIFI_SERVICE);  
			WifiInfo info = wifi.getConnectionInfo();  
			if (wifi.isWifiEnabled()) {  
				localMac = info.getMacAddress();  
				if (localMac != null) {  
					localMac = localMac.replace(":", "-").toLowerCase();  
					return localMac;  
				}  
			}  

		} catch (Exception e) {  
			e.printStackTrace();  
		}  

		return null;  
	}  

	/** 
	 * 通过callCmd("busybox ifconfig","HWaddr")获取mac地址 
	 *  
	 * @attention 需要设备装有busybox工具 
	 * @return Mac Address 
	 */  
	private static String getMacFromCallCmd() {  
		String result = "";  
		result = callCmd("busybox ifconfig", "HWaddr");  

		if (result == null || result.length() <= 0) {  
			return null;  
		}  


		// 对该行数据进行解析  
		// 例如：eth0 Link encap:Ethernet HWaddr 00:16:E8:3E:DF:67  
		if (result.length() > 0 && result.contains("HWaddr") == true) {  
			String Mac = result.substring(result.indexOf("HWaddr") + 6,  
					result.length() - 1);  
			if (Mac.length() > 1) {  
				result = Mac.replaceAll(" ", "");  
			}  
		}  

		return result;  
	}  

	public static String callCmd(String cmd, String filter) {  
		String result = "";  
		String line = "";  
		try {  
			Process proc = Runtime.getRuntime().exec(cmd);  
			InputStreamReader is = new InputStreamReader(proc.getInputStream());  
			BufferedReader br = new BufferedReader(is);  

			// 执行命令cmd，只取结果中含有filter的这一行  
			while ((line = br.readLine()) != null  
					&& line.contains(filter) == false) {  
			}  

			result = line;  
		} catch (Exception e) {  
			e.printStackTrace();  
		}  
		return result;  
	}  

	/** 
	 * 网络是否可用 
	 *  
	 * @param context 
	 * @return 
	 */  
	public static boolean IsNetWorkEnable(Context context) {  
		try {  
			ConnectivityManager connectivity = (ConnectivityManager) context  
					.getSystemService(Context.CONNECTIVITY_SERVICE);  
			if (connectivity == null) {  
				return false;  
			}  

			NetworkInfo info = connectivity.getActiveNetworkInfo();  
			if (info != null && info.isConnected()) {  
				// 判断当前网络是否已经连接  
				if (info.getState() == NetworkInfo.State.CONNECTED) {  
					return true;  
				}  
			}  

		} catch (Exception e) {  
			e.printStackTrace();  
		}  
		return false;  
	}  

	private static final int NETWORK_TYPE_UNAVAILABLE = -1;  
	// private static final int NETWORK_TYPE_MOBILE = -100;  
	private static final int NETWORK_TYPE_WIFI = -101;  

	private static final int NETWORK_CLASS_WIFI = -101;  
	private static final int NETWORK_CLASS_UNAVAILABLE = -1;  
	/** Unknown network class. */  
	private static final int NETWORK_CLASS_UNKNOWN = 0;  
	/** Class of broadly defined "2G" networks. */  
	private static final int NETWORK_CLASS_2_G = 1;  
	/** Class of broadly defined "3G" networks. */  
	private static final int NETWORK_CLASS_3_G = 2;  
	/** Class of broadly defined "4G" networks. */  
	private static final int NETWORK_CLASS_4_G = 3;  

	private static DecimalFormat df = new DecimalFormat("#.##");  

	// 适配低版本手机  
	/** Network type is unknown */  
	public static final int NETWORK_TYPE_UNKNOWN = 0;  
	/** Current network is GPRS */  
	public static final int NETWORK_TYPE_GPRS = 1;  
	/** Current network is EDGE */  
	public static final int NETWORK_TYPE_EDGE = 2;  
	/** Current network is UMTS */  
	public static final int NETWORK_TYPE_UMTS = 3;  
	/** Current network is CDMA: Either IS95A or IS95B */  
	public static final int NETWORK_TYPE_CDMA = 4;  
	/** Current network is EVDO revision 0 */  
	public static final int NETWORK_TYPE_EVDO_0 = 5;  
	/** Current network is EVDO revision A */  
	public static final int NETWORK_TYPE_EVDO_A = 6;  
	/** Current network is 1xRTT */  
	public static final int NETWORK_TYPE_1xRTT = 7;  
	/** Current network is HSDPA */  
	public static final int NETWORK_TYPE_HSDPA = 8;  
	/** Current network is HSUPA */  
	public static final int NETWORK_TYPE_HSUPA = 9;  
	/** Current network is HSPA */  
	public static final int NETWORK_TYPE_HSPA = 10;  
	/** Current network is iDen */  
	public static final int NETWORK_TYPE_IDEN = 11;  
	/** Current network is EVDO revision B */  
	public static final int NETWORK_TYPE_EVDO_B = 12;  
	/** Current network is LTE */  
	public static final int NETWORK_TYPE_LTE = 13;  
	/** Current network is eHRPD */  
	public static final int NETWORK_TYPE_EHRPD = 14;  
	/** Current network is HSPA+ */  
	public static final int NETWORK_TYPE_HSPAP = 15;  

	/** 
	 * 格式化大小 
	 *  
	 * @param size 
	 * @return 
	 */  
	public static String formatSize(long size) {  
		String unit = "B";  
		float len = size;  
		if (len > 900) {  
			len /= 1024f;  
			unit = "KB";  
		}  
		if (len > 900) {  
			len /= 1024f;  
			unit = "MB";  
		}  
		if (len > 900) {  
			len /= 1024f;  
			unit = "GB";  
		}  
		if (len > 900) {  
			len /= 1024f;  
			unit = "TB";  
		}  
		return df.format(len) + unit;  
	}  

	public static String formatSizeBySecond(long size) {  
		String unit = "B";  
		float len = size;  
		if (len > 900) {  
			len /= 1024f;  
			unit = "KB";  
		}  
		if (len > 900) {  
			len /= 1024f;  
			unit = "MB";  
		}  
		if (len > 900) {  
			len /= 1024f;  
			unit = "GB";  
		}  
		if (len > 900) {  
			len /= 1024f;  
			unit = "TB";  
		}  
		return df.format(len) + unit + "/s";  
	}  

	public static String format(long size) {  
		String unit = "B";  
		float len = size;  
		if (len > 1000) {  
			len /= 1024f;  
			unit = "KB";  
			if (len > 1000) {  
				len /= 1024f;  
				unit = "MB";  
				if (len > 1000) {  
					len /= 1024f;  
					unit = "GB";  
				}  
			}  
		}  
		return df.format(len) + "\n" + unit + "/s";  
	}  

	/** 
	 * 获取运营商 
	 *  
	 * @return 
	 */  
	public static String getProvider() {  
		String provider = "未知";  
		try {  
			TelephonyManager telephonyManager = (TelephonyManager) App
					.getAppContext().getSystemService(Context.TELEPHONY_SERVICE);  
			String IMSI = telephonyManager.getSubscriberId();  
			Log.v("tag", "getProvider.IMSI:" + IMSI);  
			if (IMSI == null) {  
				if (TelephonyManager.SIM_STATE_READY == telephonyManager  
						.getSimState()) {  
					String operator = telephonyManager.getSimOperator();  
					Log.v("tag", "getProvider.operator:" + operator);  
					if (operator != null) {  
						if (operator.equals("46000")  
								|| operator.equals("46002")  
								|| operator.equals("46007")) {  
							provider = "中国移动";  
						} else if (operator.equals("46001")) {  
							provider = "中国联通";  
						} else if (operator.equals("46003")) {  
							provider = "中国电信";  
						}  
					}  
				}  
			} else {  
				if (IMSI.startsWith("46000") || IMSI.startsWith("46002")  
						|| IMSI.startsWith("46007")) {  
					provider = "中国移动";  
				} else if (IMSI.startsWith("46001")) {  
					provider = "中国联通";  
				} else if (IMSI.startsWith("46003")) {  
					provider = "中国电信";  
				}  
			}  
		} catch (Exception e) {  
			e.printStackTrace();  
		}  
		return provider;  
	}
	/**
	 * 判断网络是否可用
	 *
	 * @return
	 */
	public static boolean isAvailableNet(){
		int currentNet = getCurrentNetworkType();
		if(currentNet == WIFI || currentNet == NET_4G){
			return true;
		}
		return false;
	}

	/** 
	 * 获取网络类型 
	 *  
	 * @return 
	 */  
	public static int  getCurrentNetworkType() {  
		int networkClass = getNetworkClass();  
		int type = NET_UNKNOWN;  
		switch (networkClass) {  
		case NETWORK_CLASS_UNAVAILABLE:  
			type = NET_NONE;  
			break;  
		case NETWORK_CLASS_WIFI:  
			type = WIFI;  
			break;  
		case NETWORK_CLASS_2_G:  
			type = NET_2G;  
			break;  
		case NETWORK_CLASS_3_G:  
			type = NET_3G;  
			break;  
		case NETWORK_CLASS_4_G:  
			type = NET_4G;  
			break;  
		case NETWORK_CLASS_UNKNOWN:  
			type = NET_UNKNOWN;  
			break;  
		}  
		return type;  
	}

	/** 
	 * 获取网络类型 
	 *  
	 * @return 
	 */  
	public static String  getNetworkType() {  
		int networkClass = getNetworkClass();  
		String type = "NET_UNKNOWN";  
		switch (networkClass) {  
		case NETWORK_CLASS_UNAVAILABLE:  
			type = "NET_NONE";  
			break;  
		case NETWORK_CLASS_WIFI:  
			type = "WIFI";  
			break;  
		case NETWORK_CLASS_2_G:  
			type = "NET_2G";  
			break;  
		case NETWORK_CLASS_3_G:  
			type = "NET_3G";  
			break;  
		case NETWORK_CLASS_4_G:  
			type = "NET_4G";  
			break;  
		case NETWORK_CLASS_UNKNOWN:  
			type = "NET_UNKNOWN";  
			break;  
		}  
		return type;  
	}

	/**
	 * 获取网络类型
	 *
	 * @return
	 */
	public static String  getNetworkType_longcha() {
		int networkClass = getNetworkClass();
		String type = "UNKNOWN";
		switch (networkClass) {
			case NETWORK_CLASS_UNAVAILABLE:
				type = "NONE";
				break;
			case NETWORK_CLASS_WIFI:
				type = "WIFI";
				break;
			case NETWORK_CLASS_2_G:
				type = "2G";
				break;
			case NETWORK_CLASS_3_G:
				type = "3G";
				break;
			case NETWORK_CLASS_4_G:
				type = "4G";
				break;
			case NETWORK_CLASS_UNKNOWN:
				type = "UNKNOWN";
				break;
		}
		return type;
	}

	private static int getNetworkClassByType(int networkType) {  
		switch (networkType) {  
		case NETWORK_TYPE_UNAVAILABLE:  
			return NETWORK_CLASS_UNAVAILABLE;  
		case NETWORK_TYPE_WIFI:  
			return NETWORK_CLASS_WIFI;  
		case NETWORK_TYPE_GPRS:  
		case NETWORK_TYPE_EDGE:  
		case NETWORK_TYPE_CDMA:  
		case NETWORK_TYPE_1xRTT:  
		case NETWORK_TYPE_IDEN:  
			return NETWORK_CLASS_2_G;  
		case NETWORK_TYPE_UMTS:  
		case NETWORK_TYPE_EVDO_0:  
		case NETWORK_TYPE_EVDO_A:  
		case NETWORK_TYPE_HSDPA:  
		case NETWORK_TYPE_HSUPA:  
		case NETWORK_TYPE_HSPA:  
		case NETWORK_TYPE_EVDO_B:  
		case NETWORK_TYPE_EHRPD:  
		case NETWORK_TYPE_HSPAP:  
			return NETWORK_CLASS_3_G;  
		case NETWORK_TYPE_LTE:  
			return NETWORK_CLASS_4_G;  
		default:  
			return NETWORK_CLASS_UNKNOWN;  
		}  
	}  

	private static int getNetworkClass() {  
		int networkType = NETWORK_TYPE_UNKNOWN;  
		try {  
			final NetworkInfo network = ((ConnectivityManager) App
					.getAppContext()  
					.getSystemService(Context.CONNECTIVITY_SERVICE))  
					.getActiveNetworkInfo();  
			if (network != null && network.isAvailable()  
					&& network.isConnected()) {  
				int type = network.getType();  
				if (type == ConnectivityManager.TYPE_WIFI) {  
					networkType = NETWORK_TYPE_WIFI;  
				} else if (type == ConnectivityManager.TYPE_MOBILE) {  
					TelephonyManager telephonyManager = (TelephonyManager) App
							.getAppContext().getSystemService(  
									Context.TELEPHONY_SERVICE);  
					networkType = telephonyManager.getNetworkType();  
				}  
			} else {  
				networkType = NETWORK_TYPE_UNAVAILABLE;  
			}  

		} catch (Exception ex) {  
			ex.printStackTrace();  
		}  
		return getNetworkClassByType(networkType);  

	}  

	public static String getWifiRssi() {  
		int asu = 85;  
		try {  
			final NetworkInfo network = ((ConnectivityManager) App
					.getAppContext()  
					.getSystemService(Context.CONNECTIVITY_SERVICE))  
					.getActiveNetworkInfo();  
			if (network != null && network.isAvailable()  
					&& network.isConnected()) {  
				int type = network.getType();  
				if (type == ConnectivityManager.TYPE_WIFI) {  
					WifiManager wifiManager = (WifiManager) App
							.getAppContext()  
							.getSystemService(Context.WIFI_SERVICE);  

					WifiInfo wifiInfo = wifiManager.getConnectionInfo();  
					if (wifiInfo != null) {  
						asu = wifiInfo.getRssi();  
					}  
				}  
			}  
		} catch (Exception e) {  
			e.printStackTrace();  
		}  
		return asu + "dBm";  
	}  

	public static String getWifiSsid() {  
		String ssid = "";  
		try {  
			final NetworkInfo network = ((ConnectivityManager) App
					.getAppContext()  
					.getSystemService(Context.CONNECTIVITY_SERVICE))  
					.getActiveNetworkInfo();  
			if (network != null && network.isAvailable()  
					&& network.isConnected()) {  
				int type = network.getType();  
				if (type == ConnectivityManager.TYPE_WIFI) {  
					WifiManager wifiManager = (WifiManager) App
							.getAppContext()  
							.getSystemService(Context.WIFI_SERVICE);  

					WifiInfo wifiInfo = wifiManager.getConnectionInfo();  
					if (wifiInfo != null) {  
						ssid = wifiInfo.getSSID();  
						if (ssid == null) {  
							ssid = "";  
						}  
						ssid = ssid.replaceAll("\"", "");  
					}  
				}  
			}  
		} catch (Exception e) {  
			e.printStackTrace();  
		}  
		return ssid;  
	}  

	/** 
	 * 检查sim卡状态 
	 *  
	 * @param
	 * @return 
	 */  
	public static boolean checkSimState() {  
		TelephonyManager tm = (TelephonyManager) App.getAppContext()
				.getSystemService(Context.TELEPHONY_SERVICE);  
		if (tm.getSimState() == TelephonyManager.SIM_STATE_ABSENT  
				|| tm.getSimState() == TelephonyManager.SIM_STATE_UNKNOWN) {  
			return false;  
		}
		return true;  
	}  

	/** 
	 * 获取android_id 
	 */  
	public static String getAndroid_id() {
		return  SystemPropertiesInvoke.getProperty("gsm.serial");

		/*String androidId = Settings.Secure.getString(App
				.getAppContext().getContentResolver(),Settings.Secure.ANDROID_ID);
		return androidId;*/
	}

	/** 
	 * 获取imei 
	 */  
	public static String getImei() {  
		TelephonyManager mTelephonyMgr = (TelephonyManager) App
				.getAppContext().getSystemService(Context.TELEPHONY_SERVICE);  
		String imei = mTelephonyMgr.getDeviceId();  
		if (imei == null) {  
			imei = "000000000000000";  
		}  
		return imei;  
	}  

	public static String getPhoneImsi() {  
		TelephonyManager mTelephonyMgr = (TelephonyManager) App
				.getAppContext().getSystemService(Context.TELEPHONY_SERVICE);  
		return mTelephonyMgr.getSubscriberId();  
	}  

	public static void getCellularSignalStrength() {
		final TelephonyManager tm = (TelephonyManager)  App
				.getAppContext().getSystemService(Context.TELEPHONY_SERVICE);  		
		PhoneStateListener mylistener = new PhoneStateListener(){  
			@Override  
			public void onSignalStrengthsChanged(SignalStrength signalStrength) {  
				super.onSignalStrengthsChanged(signalStrength);  
				String signalInfo = signalStrength.toString();  
				String[] params = signalInfo.split(" ");  
				int itedbm = 0;;
				if(tm.getNetworkType() == TelephonyManager.NETWORK_TYPE_LTE){  
					//4G网络 最佳范围   >-90dBm 越大越好  
					itedbm = Integer.parseInt(params[9]);  
				}else if(tm.getNetworkType() == TelephonyManager.NETWORK_TYPE_HSDPA ||  
						tm.getNetworkType() == TelephonyManager.NETWORK_TYPE_HSPA ||  
						tm.getNetworkType() == TelephonyManager.NETWORK_TYPE_HSUPA ||  
						tm.getNetworkType() == TelephonyManager.NETWORK_TYPE_UMTS){  
					//3G网络最佳范围  >-90dBm  越大越好  ps:中国移动3G获取不到  返回的无效dbm值是正数（85dbm）  
					//在这个范围的已经确定是3G，但不同运营商的3G有不同的获取方法，故在此需做判断 判断运营商与网络类型的工具类在最下方  
					String yys = getProvider();//获取当前运营商  
					if (yys=="中国移动") { 
						itedbm = 0;  //中国移动3G不可获取，故在此返回0  
					}else if (yys=="中国联通") {  
						itedbm = signalStrength.getCdmaDbm();  
					}else if (yys=="中国电信") {  
						itedbm = signalStrength.getEvdoDbm();   
					}  
				}else{  
					//2G网络最佳范围>-90dBm 越大越好  
					int asu = signalStrength.getGsmSignalStrength();
					itedbm = -113 + 2*asu;   
				}
				int asu = (itedbm + 113)/2;
				App.dbm = asu;
			}  
		};  
		tm.listen(mylistener, PhoneStateListener.LISTEN_SIGNAL_STRENGTHS);  
	}


	/**
	 * 基站id
	 */
	public static int getCId(){
		int cellId = -1;
		TelephonyManager tm = (TelephonyManager)  App
				.getAppContext().getSystemService(Context.TELEPHONY_SERVICE); 
		String yys = getProvider();		
		if (yys=="中国移动" || yys=="中国联通") { 
			GsmCellLocation location = (GsmCellLocation) tm.getCellLocation();  
			cellId = location.getCid();	
		}else {  
			CdmaCellLocation location1 = (CdmaCellLocation) tm.getCellLocation(); 
			cellId = location1.getBaseStationId(); 
		}  
		GsmCellLocation location = (GsmCellLocation) tm.getCellLocation();  
		cellId = location.getCid();  
		return cellId;
	}

}  
